#include <iostream>

using namespace std;

// 如何判断 n 的质因数只有 2, 3 或 5?
// 如果，n 的质因数只有 2, 3 或 5，那么当我们不断尝试用 n 去除以这些数字，最终得到的结果应该是 ？ 1
// n = 120
// n = 2 * 2 * 2 * 3 * 5
// 120 是一个丑数 => 1
// 52
// 18 = 2 * 3 * 3 => 1
bool isUglyNum(int n) {
  // 能被 2 整除的时候，就不断的除以 2

  // 能被 3 整除的时候，就不断的除以 3

  // 能被 5 整除的时候，就不断的除以 5

  // 执行到这里的时候，返回此时的 n 和 1 的比较结果
  return n == 1;
}

// 递归的思路
// 自己调用自己
// 递归有两个要素：
// 1. 终止条件，也就是让递归停下来的条件，不需要递归就能直接得到结果的情况；
// 2. 递归过程；
bool isUglyNumR(int n) {
  // 什么可以作为判断丑数的终止条件？
  // n == 1,2,3,4,5,6
  // 7
  // 判断丑数的终止条件
  if (n <= 0) { return false; }
  if (n < 7) { return true; }

  // 递归过程
  // 能被 2 整除，就不断的去除以 2
  if (n % 2 == 0) {
    return isUglyNumR(n / 2); // 这个递归调用肯定要执行到终止条件为止
  }

  if (n % 3 == 0) {
    return isUglyNumR(n / 3); // 这个递归调用肯定要执行到终止条件为止
  }

  if (n % 5 == 0) {
    return isUglyNumR(n / 5); // 这个递归调用肯定要执行到终止条件为止
  }

  // 如果程序可以执行到这里
  return false;
}

// 判断 t 是否为 s 的一个合法子序列
// s : abcde
//      ^i
// t : ace
//         ^j

bool isSubsequence(string s, string t) {
  int i = 0;
  int j = 0;

  while (i < s.size() && j < t.size()) {
    if (s[i] == t[j]) {
      // i j 位置上的字符相等
      ++i;
      ++j;
    }
    else {
      ++i;
    }
  }

  // 执行到这里
  // 要么 i 出界了
  // 要么 j 出界了
  if (j == t.size()) {
    return true;
  }
  else {
    return false;
  }
}

int main(int argc, char const *argv[])
{
  /* code */
  return 0;
}
